// pages/home/home.ts
import {
  PAGE_SEARCH_RESULTS,
  PAGE_LOOK_FOR_TECH_PARAMS,
  PAGE_BULK_MATERIALS,
  PAGE_GROUP_LIST,
  PAGE_MEMBERSHIP_REGISTER,
  PAGE_DEMAND_DETAIL,
  PAGE_GROUP_DETAIL,
  PAGE_DEMAND_LIST,
  goToPage,
  PAGE_BULK_MATERIALS_CATEGORY,
  PAGE_BULK_PROCESSING_CATEGORY,
  PAGE_BULK_MATERIAL_DETAIL, PAGE_PRODUCT_LIST_PROCESSING
} from '../../config/pages';
import { getPublishHomeList } from '../../api/publish';
import { formatSpecification } from '../../utils/util';
import util from '../../utils/util';
import {HTTP_REQUEST_URL} from "../../config/app";

Page({
  data: {
    searchValue: '',
    demandList: [],
    inventoryList: [],
    groupList: [],
    // 广告相关
    showAdSplash: false,
    adImage: '',
    // 弹窗广告相关
    showModalAd: false,
    modalAdImage: '',
    modalAdLink: '',
    // 防止弹窗广告重复显示的标志
    modalAdShown: false,
  },

  // 弹窗广告延迟调用的定时器ID
  modalAdTimeout: null as number | null,

  onLoad() {
    console.log('首页加载完成');
    // 重置弹窗广告显示标志，允许每次进入首页都显示弹窗广告
    this.setData({
      modalAdShown: false,
      showModalAd: false
    });
    this.checkAndShowAd();
  },

  onShow() {
    this.loadLatestData();
    console.log('首页显示');
    // 更新TabBar选中状态
    if (typeof this.getTabBar === 'function' && this.getTabBar()) {
      this.getTabBar().setData({
        selected: 0
      });
    }
    
    // 清除之前的延迟调用，避免重复显示
    if (this.modalAdTimeout) {
      clearTimeout(this.modalAdTimeout);
      this.modalAdTimeout = null;
    }
    
    // 检查弹窗广告显示条件
    this.checkModalAdDisplay();
  },

  // 搜索相关
  onSearchChange(e: any) {
    this.setData({
      searchValue: e.detail.value
    });
  },

  onSearchSubmit(e: any) {
    const value = e.detail.value;
    console.log('搜索内容:', value);
    
    // 如果搜索内容为空，显示提示
    if (!value || value.trim() === '') {
      wx.showToast({
        title: '请输入搜索内容',
        icon: 'none'
      });
      return;
    }
    
    // 跳转到搜索结果页面，传递搜索关键词
    goToPage(PAGE_SEARCH_RESULTS, { keyword: value.trim() });
  },

  // 快捷入口导航
  navigateToBulkMaterials() {
    goToPage(PAGE_BULK_MATERIALS);
  },

  navigateToGroupOrders() {
    goToPage(PAGE_GROUP_LIST);
  },

  navigateToMaterialSearch() {
    goToPage(PAGE_BULK_MATERIALS_CATEGORY)
  },

  navigateToProcessServices() {
    goToPage(PAGE_PRODUCT_LIST_PROCESSING)
  },

  navigateToTechParams() {
    goToPage(PAGE_LOOK_FOR_TECH_PARAMS);
  },

  navigateToExhibition() {
    wx.navigateTo({
      url: '/pages/common/article-list/article-list'
    });
  },

  // 轮播图链接跳转事件
  onBannerLinkTap(e: any) {
    const { linkUrl } = e.detail;
    console.log('轮播图链接跳转:', linkUrl);
    util.navigateToAdLink(linkUrl);
  },

  // 加载最新数据
  async loadLatestData() {
    try {
      // 加载最新散料（inventory类型，获取2条）
      await this.loadLatestInventory();
      // 加载最新拼单（group类型，获取2条）
      await this.loadLatestGroups();
    } catch (error) {
      console.error('加载最新数据失败:', error);
    }
  },

  // 加载最新散料
  async loadLatestInventory() {
    try {
      const res: any = await getPublishHomeList({
        type: 'inventory',
        page: 1,
        limit: 2
      } as any);
      
      if (res.status === 200 && res.data && res.data.list) {
        const inventoryList = res.data.list.map((item: any) => {
          return {
            id: item.id,
            model: item.product_model || item.product_name || '暂无型号',
            type: item.type,
            category: item.category || 'material',
            typeText: this.getTypeText(item.type),
            categoryName: item.product_category,
            productName: item.product_name,
            params: formatSpecification(item.tech_params || item.spec || ''),
            requirements: item.remark || '',
            location: `${item.province || ''}${item.city || ''}`,
            date: this.formatDate(item.add_time),
            formatted_date: this.formatDate(item.add_time)
          };
        });
        this.setData({ inventoryList });
      }
    } catch (error) {
      console.error('加载最新散料失败:', error);
    }
  },

  // 加载最新拼单
  async loadLatestGroups() {
    try {
      const res: any = await getPublishHomeList({
        type: 'group',
        page: 1,
        limit: 2
      } as any);
      
      if (res.status === 200 && res.data && res.data.list) {
        const groupList = res.data.list.map((item: any) => {
          return {
            id: item.id,
            model: item.product_model || item.product_name || '暂无型号',
            category: item.product_category || '未分类',
            name: item.product_name,
            quantity: formatSpecification(item.spec || item.total_amount || '暂无数量'),
            total: item.total_amount || '暂无总量',
            participants: this.getParticipantAvatars(item.participant_count),
            participantCount: item.participant_count || 0,
            participants_display: this.formatParticipants(item.participants || []),
            location: `${item.province || ''}${item.city || ''}`,
            date: this.formatDate(item.add_time),
            formatted_date: this.formatDate(item.add_time)
          };
        });
        this.setData({ groupList });
      }
    } catch (error) {
      console.error('加载最新拼单失败:', error);
    }
  },

  // 获取类型文本
  getTypeText(type: string) {
    const typeMap: any = {
      'demand': '求购',
      'group': '拼单',
      'material': '材料',
      'processing': '加工',
      'inventory': '库存'
    };
    return typeMap[type] || type;
  },

  // 格式化日期
  formatDate(dateStr: string) {
    if (!dateStr) return '';
    
    // iOS兼容性处理：将 "yyyy-MM-dd HH:mm:ss" 格式转换为 "yyyy/MM/dd HH:mm:ss"
    let formattedDateStr = dateStr;
    if (dateStr.includes('-') && dateStr.includes(' ')) {
      formattedDateStr = dateStr.replace(/-/g, '/');
    }
    
    const date = new Date(formattedDateStr);
    
    // 检查日期是否有效
    if (isNaN(date.getTime())) {
      console.warn('无效的日期格式:', dateStr);
      return dateStr; // 返回原始字符串
    }
    
    const year = date.getFullYear();
    const month = String(date.getMonth() + 1).padStart(2, '0');
    const day = String(date.getDate()).padStart(2, '0');
    return `${year}-${month}-${day}`;
  },

  // 获取参与者头像列表（用于显示）
  getParticipantAvatars(count: number) {
    const maxShow = 3; // 最多显示3个头像
    const avatars = [];
    const displayCount = Math.min(count, maxShow);
    
    for (let i = 0; i < displayCount; i++) {
      // 简单使用首字母作为头像内容
      avatars.push(String.fromCharCode(65 + i)); // A, B, C...
    }
    
    return avatars;
  },

  // 查看更多求购
  navigateToDemandList() {
    goToPage(PAGE_DEMAND_LIST, {}, 'switchTab');
  },

  // 查看更多散料
  navigateToInventoryList() {
    goToPage(PAGE_BULK_MATERIALS);
  },

  // 查看更多拼单
  navigateToGroupList() {
    goToPage(PAGE_GROUP_LIST);
  },

  // 求购详情
  navigateToDemandDetail(e: any) {
    const id = e.currentTarget.dataset.id;
    if (!id) {
      wx.showToast({
        title: '数据异常',
        icon: 'none'
      });
      return;
    }
    // 跳转到求购详情页
    goToPage(PAGE_DEMAND_DETAIL, { id });
  },

  // 散料详情
  navigateToBulkDetail(e: any) {
    const id = e.currentTarget.dataset.id;
    if (!id) {
      wx.showToast({
        title: '数据异常',
        icon: 'none'
      });
      return;
    }
    goToPage(PAGE_BULK_MATERIAL_DETAIL, { id });
  },

  // 拼单详情
  navigateToGroupDetail(e: any) {
    const id = e.currentTarget.dataset.id;
    if (!id) {
      wx.showToast({
        title: '数据异常',
        icon: 'none'
      });
      return;
    }
    // 跳转到拼单详情页
    goToPage(PAGE_GROUP_DETAIL, { id });
  },

  // 付费会员
  navigateToMembership() {
    goToPage(PAGE_MEMBERSHIP_REGISTER);
  },

  // 格式化参与者信息
  formatParticipants(participants: any[]) {
    const total = participants.length;
    const displayAvatars = participants.slice(0, 4).map((p: any) => {
      // 获取用户名称（优先使用real_name，其次nickname）
      const name = p.user?.real_name || p.user?.nickname || '匿';
      // 取第一个字
      const firstChar = name.charAt(0);
      return {
        name: firstChar,
        uid: p.uid
      };
    });

    return {
      avatars: displayAvatars,
      hasMore: total > 4,
      total: total
    };
  },

  // 检查并显示广告
  checkAndShowAd() {
    try {
      const versionImg = 1;
      // 每次进入都显示广告
      const adImages = [
        HTTP_REQUEST_URL+'/statics/images/homead1.png?version='+versionImg,
        HTTP_REQUEST_URL+'/statics/images/homead2.png?version='+versionImg,
        HTTP_REQUEST_URL+'/statics/images/homead3.png?version='+versionImg,
      ];
      
      // 随机选择一张广告图片
      const randomIndex = Math.floor(Math.random() * adImages.length);
      console.log('选择的广告图片:', randomIndex);
      const selectedAdImage = adImages[randomIndex];
      
      // 显示广告
      this.setData({
        showAdSplash: true,
        adImage: selectedAdImage
      });
      
      console.log('显示广告:', selectedAdImage);
      
      // 设置一个备用定时器，如果开屏广告没有正常结束，确保模态框广告仍然会显示
      setTimeout(() => {
        if (this.data.showAdSplash) {
          console.log('开屏广告超时，强制显示模态框广告');
          this.hideAd();
          this.showModalAdAfterSplash();
        }
      }, 10000); // 10秒后如果开屏广告还在显示，强制关闭并显示模态框广告
      
    } catch (error) {
      console.error('显示广告失败:', error);
      // 如果开屏广告显示失败，直接显示模态框广告
      this.showModalAdAfterSplash();
    }
  },

  // 检查弹窗广告显示条件
  checkModalAdDisplay() {
    console.log('检查弹窗广告显示条件');
    
    // 如果弹窗广告已经显示过，不再显示
    if (this.data.modalAdShown) {
      console.log('弹窗广告已经显示过，跳过显示');
      return;
    }
    
    // 如果当前正在显示开屏广告，等待开屏广告结束
    if (this.data.showAdSplash) {
      console.log('开屏广告正在显示，等待结束');
      // 设置一个较长的延迟，等待开屏广告自然结束或被手动关闭
      this.modalAdTimeout = setTimeout(() => {
        this.checkModalAdDisplay();
        this.modalAdTimeout = null;
      }, 2000);
      return;
    }
    
    // 直接显示弹窗广告
    this.showModalAdDirectly();
  },

  // 开屏广告结束后显示模态框广告
  showModalAdAfterSplash() {
    console.log('开屏广告结束，准备显示模态框广告');
    
    // 清除所有延迟调用，避免重复显示
    if (this.modalAdTimeout) {
      clearTimeout(this.modalAdTimeout);
      this.modalAdTimeout = null;
      console.log('已清除所有延迟调用');
    }
    
    // 检查是否已经显示过弹窗广告
    if (this.data.modalAdShown) {
      console.log('弹窗广告已经显示过，跳过重复显示');
      return;
    }
    
    // 立即显示弹窗广告，不需要延迟
    this.showModalAdDirectly();
  },

  // 广告跳过事件
  onAdSkip(e: any) {
    console.log('广告跳过，倒计时:', e.detail.countdown);
    this.hideAd();
    // 用户手动关闭开屏广告后，立即显示弹窗广告
    this.showModalAdAfterSplash();
  },

  // 广告点击事件
  onAdTap(e: any) {
    console.log('广告被点击:', e.detail.adImage);
    // 可以在这里添加广告点击统计或跳转逻辑
    this.hideAd();
    // 用户点击开屏广告后，立即显示弹窗广告
    this.showModalAdAfterSplash();
  },

  // 隐藏tabBar事件
  onHideTabBar() {
    this.hideTabBar();
  },

  // 显示tabBar事件
  onShowTabBar() {
    this.showTabBar();
  },

  // 隐藏广告
  hideAd() {
    this.setData({
      showAdSplash: false
    });
    
    console.log('广告已隐藏');
  },

  // 隐藏tabBar
  hideTabBar() {
    try {
      const tabBar = this.getTabBar();
      if (tabBar && typeof tabBar.setData === 'function') {
        tabBar.setData({
          showTabBar: false
        });
      }
    } catch (error) {
      console.warn('隐藏tabBar失败:', error);
    }
  },

  // 显示tabBar
  showTabBar() {
    try {
      const tabBar = this.getTabBar();
      if (tabBar && typeof tabBar.setData === 'function') {
        tabBar.setData({
          showTabBar: true
        });
      }
    } catch (error) {
      console.warn('显示tabBar失败:', error);
    }
  },

  // 检查并显示弹窗广告（保留用于兼容性，实际使用checkModalAdDisplay）
  checkAndShowModalAd() {
    console.log('checkAndShowModalAd被调用，重定向到checkModalAdDisplay');
    this.checkModalAdDisplay();
  },

  // 直接显示弹窗广告
  showModalAdDirectly() {
    try {
      console.log('开始检查弹窗广告配置...');
      const basicConfig = wx.getStorageSync('BASIC_CONFIG');
      console.log('BASIC_CONFIG:', basicConfig);
      
      if (basicConfig && basicConfig.home_modal_image) {
        const modalConfig = basicConfig.home_modal_image;
        console.log('弹窗广告配置:', modalConfig);
        
        if (modalConfig.pic_url && modalConfig.link_url) {
          // 检查是否是SVG数据URL，如果是则使用测试图片
          let imageUrl = modalConfig.pic_url;
          if (imageUrl.startsWith('data:image/svg+xml')) {
            console.log('检测到SVG数据URL，使用测试图片替代');
            imageUrl = 'https://via.placeholder.com/300x200/007bff/ffffff?text=弹窗广告';
          }
          
          this.setData({
            showModalAd: true,
            modalAdImage: imageUrl,
            modalAdLink: modalConfig.link_url,
            modalAdShown: true
          });
          console.log('弹窗广告显示成功:', {
            showModalAd: true,
            modalAdImage: imageUrl,
            modalAdLink: modalConfig.link_url,
            modalAdShown: true
          });
          
          // 延迟检查数据状态
          setTimeout(() => {
            console.log('延迟检查弹窗状态:', {
              showModalAd: this.data.showModalAd,
              modalAdImage: this.data.modalAdImage,
              modalAdLink: this.data.modalAdLink
            });
            
            // 强制触发页面更新
            this.setData({
              showModalAd: true
            });
            console.log('强制设置弹窗显示状态');
            
            // 检查图片加载状态
            const query = this.createSelectorQuery();
            query.select('.modal-ad-container').boundingClientRect();
            query.select('.modal-ad-image').boundingClientRect();
            query.exec((res) => {
              console.log('容器和图片尺寸:', res);
            });
          }, 100);
        } else {
          console.log('弹窗广告配置不完整:', modalConfig);
          // 显示默认弹窗广告
          this.showDefaultModalAd();
        }
      } else {
        console.log('未找到弹窗广告配置，BASIC_CONFIG:', basicConfig);
        // 显示默认弹窗广告
        this.showDefaultModalAd();
      }
    } catch (error) {
      console.error('直接显示弹窗广告失败:', error);
      // 显示默认弹窗广告
      this.showDefaultModalAd();
    }
  },

  // 显示默认弹窗广告
  showDefaultModalAd() {
    try {
      const versionImg = 1;
      const adImages = [
        HTTP_REQUEST_URL+'/statics/images/homead1.png?version='+versionImg,
        HTTP_REQUEST_URL+'/statics/images/homead2.png?version='+versionImg,
        HTTP_REQUEST_URL+'/statics/images/homead3.png?version='+versionImg,
      ];
      
      // 随机选择一张广告图片
      const randomIndex = Math.floor(Math.random() * adImages.length);
      const selectedAdImage = adImages[randomIndex];
      
      this.setData({
        showModalAd: true,
        modalAdImage: selectedAdImage,
        modalAdLink: 'https://www.example.com',
        modalAdShown: true
      });
      console.log('显示默认弹窗广告:', selectedAdImage);
    } catch (error) {
      console.error('显示默认弹窗广告失败:', error);
    }
  },

  // 弹窗广告点击事件
  onModalAdTap() {
    console.log('弹窗广告被点击，链接:', this.data.modalAdLink);
    
    if (!this.data.modalAdLink) {
      wx.showToast({
        title: '链接无效',
        icon: 'none'
      });
      return;
    }
    
    // 关闭弹窗
    this.hideModalAd();
    
    // 跳转到链接
    util.navigateToAdLink(this.data.modalAdLink);
  },

  // 关闭弹窗广告
  hideModalAd() {
    console.log('关闭弹窗广告');
    
    // 清除所有相关的定时器，防止延迟调用导致重复显示
    if (this.modalAdTimeout) {
      clearTimeout(this.modalAdTimeout);
      this.modalAdTimeout = null;
      console.log('已清除弹窗广告相关定时器');
    }
    
    this.setData({
      showModalAd: false,
      modalAdShown: true  // 标记为已显示，防止重复显示
    });
    
    console.log('弹窗广告已关闭，状态:', {
      showModalAd: this.data.showModalAd,
      modalAdShown: this.data.modalAdShown
    });
  }

});